/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package mp3tagger;

import java.io.UnsupportedEncodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;

/**
 *
 * @author Rajab
 */
public class Util {

    static final String UTF8 = "UTF-8";
    static final String GB2312 = "GB2312";
    static final String ISO = "ISO-8859-1";

    /**
     * <pre>
     * 根据字符串的字符集自动解析，返回正确的字符串
     *
     * 判断流程：
     *  设传入的字符串为inStr
     * 1、当inStr为null或为空时，返回""
     * 2、取出inStr的代码点，当有代码点 大于 255 时，既代码点占用多个字节，说明是中文或其他多字节文字，直接返回inStr
     * 3、将 inStr 用 GB2312 解析 得到 inStr_GB
     * 4、将 inStr 用 UTF8 解析 得到 inStr_UTF
     * 5、将 inStr_GB 转 UTF8 得到 inStr_GB_UTF
     * 6、如果 inStr_UTF == inStr_GB_UTF 则inStr 为GB2312字符集，返回 inStr_GB ，否则返回 inStr_UTF
     *
     *
     * </pre>
     * @param inStr 需解析的字符串
     * @return String 解析后的字符串
     */
    public static String praseString(String inStr) {
        int i = 0;
        byte[] b;

        try {
            //当传入参数为null或为空时，返回""
            if ((inStr == null) || ("".equals(inStr))) {
                return "";
            }

            //当代码点 大于 255 时，说明是中文或其他多字节文字，直接返回
            for (i = 0; i < inStr.codePointCount(0, inStr.length()); i++) {
                //EchoStr.pln("[codePointAt i= " + i + " ]" + inStr.codePointAt(i) + "");
                if (inStr.codePointAt(i) > 255) {
                    return inStr;
                }
            }


            b = inStr.getBytes(ISO);

            String inStrGB = new String(b, GB2312);
            String inStrUTF = new String(b, UTF8);

            String inStrGB_UTF = new String(inStrGB.getBytes(GB2312), UTF8);
            if (inStrGB_UTF.equals(inStrUTF)) {
                return inStrGB;
            } else {
                return inStrUTF;
            }
        } catch (Exception e) {
            System.out.println(e);
            return inStr;
        }
    }

    public static String praseString(byte[] byteInStrArray) {
        int i = 0;

        try {

            int inCount = byteInStrArray.length;

            for (i = 0; i < inCount; i++) {
                //如果中间有0，则后面全为0，防止C传入的字节流有未初始化的结构
                if (byteInStrArray[i] == 0) {
                    break;
                }
            }

            byte[] byteInStr = new byte[i];
            System.arraycopy(byteInStrArray, 0, byteInStr, 0, i);

            String inStrGB = new String(byteInStr, GB2312);
            String inStrUTF = new String(byteInStr, UTF8);

            String inStrGB_UTF = new String(inStrGB.getBytes(GB2312), UTF8);

            if (inStrGB_UTF.equals(inStrUTF)) {
                return inStrGB;
            } else {
                return inStrUTF;
            }
        } catch (Exception e) {
            System.out.println(e);
            return "";
        }
    }

    /**
     *
     *
     * <pre>
     * 判断字符串的字符集
     *
     * 判断流程：
     *  设传入的字符串为inStr
     * 1、当inStr为null或为空时，返回""
     * 2、取出inStr的代码点，当有代码点 大于 255 时，既代码点占用多个字节，说明是中文或其他多字节文字，直接返回 gb2312
     * 3、将 inStr 用 GB2312 解析 得到 inStr_GB
     * 4、将 inStr 用 UTF8 解析 得到 inStr_UTF
     * 5、如果 inStr_GB == inStr 和 inStr_UTF == inStr 则 inStr 为 ISO8859 字符集。
     * 5、将 inStr_GB 转 UTF8 得到 inStr_GB_UTF
     * 6、如果 inStr_UTF == inStr_GB_UTF 则 inStr 为GB2312字符集，返回 inStr_GB ，否则返回 inStr_UTF
     *
     *
     * </pre>
     * @param inStr 需确认字符集的字符串
     * @return String 该字符串的字符集
     */
    public static String praseStringCharset(String inStr) {
        //////////////
        int i = 0;
        byte[] b;

        try {
            //当传入参数为null或为空时，返回""
            if ((inStr == null) || ("".equals(inStr))) {
                return "";
            }

            //当代码点 大于 255 时，说明是中文或其他多字节文字，直接返回
            for (i = 0; i < inStr.codePointCount(0, inStr.length()); i++) {
                if (inStr.codePointAt(i) > 255) {
                    return GB2312;
                }
            }

            b = inStr.getBytes(ISO);


            String inStrGB = new String(b, GB2312);
            String inStrUTF = new String(b, UTF8);

            if ((inStrGB.equals(inStr)) && (inStrUTF.equals(inStr))) {
                return ISO;
            }

            String inStrGB_UTF = new String(inStrGB.getBytes(GB2312), UTF8);

            if (inStrGB_UTF.equals(inStrUTF)) {
                return GB2312;
            } else {
                return UTF8;
            }
        } catch (Exception e) {
            System.out.println(e);
            return "";
        }
    }

    public static void getString(String str) {
        String ret = str;
        CharsetEncoder u = Charset.forName("UTF-8").newEncoder();
        CharsetEncoder i = Charset.forName("ISO-8859-1").newEncoder();
        CharsetEncoder gbk = Charset.forName("GBK").newEncoder();
        CharsetEncoder gb2312 = Charset.forName("GB2312").newEncoder();
        System.out.println("UTF-8:" + u.canEncode(str));
        System.out.println("iso:" + i.canEncode(str));
        System.out.println("gbk:" + gbk.canEncode(str));
        System.out.println("gb2312:" + gb2312.canEncode(str));
    }

    public static String isotogbk(String s) {



        try {

            byte[] b = s.getBytes("iso-8859-1");

            String str = new String(b, "GBK");

            return str;



        } catch (UnsupportedEncodingException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();//log4j

        }
        return null;
    }
}
